package com.njupt.huawei;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @Author: wujiaming
 * @CreateTime: 2025/4/23 20:55
 * @Description: 最小操作次数
 * @Version: 1.0
 */


public class Main3 {

    static final int MOD = 1000000007;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] matrix = new int[n][n];
        // 读取输入的矩阵
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = sc.nextInt();
            }
        }

        // 生成顺时针螺旋顺序的数组
        List<Integer> spiral = new ArrayList<>();
        for (int k = 0; k <= n / 2; k++) { // 处理每一层，从外到内
            int currentSize = n - 2 * k;   // 当前层的边长
            if (currentSize <= 0) {        // 边界条件检查
                break;
            }

            // 顶行:从左到右
            for (int j = k; j < n - k; j++) {
                spiral.add(matrix[k][j]);
            }

            if (currentSize == 1) {  // 处理奇数层最内层单个元素的情况
                break;
            }

            // 右列：从上到下（排除顶行最后一个元素）
            for (int i = k + 1; i < n - k; i++) {
                spiral.add(matrix[i][n - k - 1]);
            }

            // 底行：从右到左（排除右列最后一个元素）
            for (int j = n - k - 2; j >= k; j--) {
                spiral.add(matrix[n - k - 1][j]);
            }

            // 左列：从下到上（排除底行第一个元素）
            for (int i = n - k - 2; i > k; i--) {
                spiral.add(matrix[i][k]);
            }
        }

        // 计算逆序对数目
        long inversions = 0;
        FenwickTree ft = new FenwickTree(n * n);// 树状数组，处理元素范围为1到n^2

        // 逆序处理螺旋数组中的元素
        for (int i = spiral.size() - 1; i >= 0; i--) {
            int num = spiral.get(i);
            // 查询已处理元素中比当前元素小的数目，即当前元素的逆序对贡献
            inversions += ft.query(num - 1);
            // 更新树状数组，将当前元素加入
            ft.update(num, 1);
        }
        // 输出结果取模
        System.out.println(inversions % MOD);

    }

    // 树状数组实现
    static class FenwickTree {
        int size;  // 树状数组的大小
        int[] tree; // 存储数据的数组

        public FenwickTree(int max) {
            this.size = max + 2;  // 避免越界
            tree = new int[size];
        }

        // 更新操作：在idx位置增加delta
        public void update(int idx, int delta) {
            while (idx < size) {
                tree[idx] += delta;
                idx += idx & -idx;  // 移动到父节点
            }
        }


        // 查询操作：计算前缀和[1, idx]
        public int query(int idx) {
            int res = 0;
            while (idx > 0) {
                res += tree[idx];
                idx -= idx & -idx;  // 移动到前一个区间
            }
            return res;
        }
    }
}
